Micron Document
<!DOCTYPE html>
<html class="client-nojs vector-feature-language-in-header-enabled vector-feature-language-in-main-page-header-disabled vector-feature-page-tools-pinned-disabled vector-feature-toc-pinned-clientpref-0 vector-toc-not-available vector-feature-main-menu-pinned-disabled vector-feature-limited-width-clientpref-1 vector-feature-limited-width-content-enabled vector-feature-custom-font-size-clientpref-1 vector-feature-appearance-pinned-clientpref-0 skin-theme-clientpref-day vector-sticky-header-enabled" lang="de" dir="ltr"><head>
<meta charset="UTF-8">
<title>Pascal (Programmiersprache)</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" type="image/png" href="./_res_/favicon.png">
<link rel="canonical" href="https://de.wikipedia.org/wiki/Pascal_(Programmiersprache)"> <link href="./_mw_/ext.cite.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.pygments.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.wikimediamessages.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.icons.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.search.codex.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.styles.css" rel="stylesheet" type="text/css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link href="./_mw_/ext.gadget.citeRef.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.defaultPlainlinks.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonHide.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonLayout.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonStyle.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiDarkmode.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiResponsive.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.specialSearch.css" rel="stylesheet" type="text/css">
<link rel="stylesheet" type="text/css" href="./_mw_/site.styles.css">
<link rel="stylesheet" type="text/css" href="./_mw_/noscript.css">
<link rel="stylesheet" type="text/css" href="./_res_/footer.css">
<link rel="stylesheet" type="text/css" href="./_res_/vector-2022.css">
</head>
<body class="skin--responsive skin-vector skin-vector-search-vue mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Pascal_Programmiersprache rootpage-Pascal_Programmiersprache skin-vector-2022 action-view">
<div class="mw-page-container">
<div class="mw-page-container-inner">
<div class="mw-content-container">
<main id="content" class="mw-body">
<header class="mw-body-header vector-page-titlebar">
<h1 id="firstHeading" class="firstHeading mw-first-heading"><span class="mw-page-title-main">Pascal (Programmiersprache)</span></h1>
</header>
<a id="top"></a>
<div id="bodyContent" class="vector-body ve-init-mw-desktopArticleTarget-targetContainer" aria-labelledby="firstHeading" data-mw-ve-target-container="">
<div id="contentSub">
<div id="mw-content-subtitle"></div>
</div>
<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="de" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="de" dir="ltr"><table class="float-right infobox toccolours toptextcells" style="font-size:90%; margin-top:0; width:21em;">

<tbody><tr>
<th colspan="2" class="hintergrundfarbe6" style="font-size:larger;">Pascal
</th></tr>




<tr>
<th colspan="2" class="hintergrundfarbe5" style="font-size:105%; text-align:center;">Basisdaten
</th></tr>
<tr>
<td><b><a href="Programmierparadigma" title="Programmierparadigma">Paradigmen</a>:</b>
</td>
<td><a href="Imperative_Programmierung" title="Imperative Programmierung">imperativ</a>, <a href="Strukturierte_Programmierung" title="Strukturierte Programmierung">strukturiert</a>
</td></tr>
<tr>
<td><b>Erscheinungsjahr:</b>
</td>
<td>1971
</td></tr>

<tr>
<td><b>Designer:</b>
</td>
<td><span class="wikidata-content"><a href="Niklaus_Wirth" title="Niklaus Wirth">Niklaus Wirth</a></span>
</td></tr>
<tr>
<td><b>Entwickler:</b>
</td>
<td><a href="Niklaus_Wirth" title="Niklaus Wirth">Niklaus Wirth</a>
</td></tr>
<tr>
<td><b>Aktuelle&nbsp;<a href="Version_(Software)" title="Version (Software)">Version</a></b>
</td>
<td class="wikidata-content" style="white-space:nowrap;">ISO/IEC 10206:1991 Stage: 90.93&nbsp;(29 июля 2008 года)
</td></tr>


<tr>
<td><b><a href="Typisierung_(Informatik)" title="Typisierung (Informatik)">Typisierung</a>:</b>
</td>
<td><a href="Starke_Typisierung" title="Starke Typisierung">stark</a>, <a href="Statische_Typisierung" title="Statische Typisierung">statisch</a>
</td></tr>


<tr>
<td><b>Dialekte:</b>
</td>
<td><a href="University_of_California%2C_San_Diego" title="University of California, San Diego">UCSD</a>-Pascal, <a href="Borland_Pascal" title="Borland Pascal">Borland Pascal</a> <a href="Turbo_Pascal" title="Turbo Pascal">Turbo&nbsp;Pascal</a>
</td></tr>


<tr>
<td><b>Beeinflusst von:</b>
</td>
<td><a href="Algol_60" title="Algol 60">ALGOL</a>
</td></tr>
<tr>
<td><b>Beeinflusste:</b>
</td>
<td><a href="Modula-2" title="Modula-2">Modula-2</a>, <a href="Ada_(Programmiersprache)" title="Ada (Programmiersprache)">Ada</a>, <a href="Oberon_(Programmiersprache)" title="Oberon (Programmiersprache)">Oberon</a>, <a href="Object_Pascal" title="Object Pascal">Object Pascal</a>, <a href="WEB_(Programmiersprache)" title="WEB (Programmiersprache)">WEB</a>, <a href="Seed7" title="Seed7">Seed7</a>
</td></tr>





</tbody></table>

<p><b>Pascal</b> ist eine Anfang der 1970er Jahre entwickelte <a href="Imperative_Programmierung" title="Imperative Programmierung">imperative Programmiersprache</a>.
</p><p>Pascal wurde von <a href="Niklaus_Wirth" title="Niklaus Wirth">Niklaus Wirth</a> an der <a href="Eidgen%C3%B6ssische_Technische_Hochschule_Z%C3%BCrich" class="mw-redirect" title="Eidgenössische Technische Hochschule Zürich">ETH Zürich</a> als <a href="Bildungsorientierte_Programmiersprache" title="Bildungsorientierte Programmiersprache">Lehrsprache</a> eingeführt, um die <a href="Strukturierte_Programmierung" title="Strukturierte Programmierung">strukturierte Programmierung</a> zu lehren.<sup id="cite_ref-1" class="reference"><a href="#cite_note-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>
</p>

<div class="mw-heading mw-heading2"><h2 id="Allgemeines">Allgemeines</h2></div>
<p>Pascal ist eine Weiterentwicklung von <a href="Algol_60" title="Algol 60">Algol 60</a>. Es lehnt sich in seiner <a href="Syntax" title="Syntax">Syntax</a> an die <a href="Englische_Grammatik" title="Englische Grammatik">englische Grammatik</a> an. Dies soll die Lesbarkeit für Programmiereinsteiger verbessern; Pascal ist daher als Lehrsprache geeignet. Seine Verbreitung in der professionellen Programmierung fand es als <a href="Borland_Pascal" title="Borland Pascal">Borland</a>/<a href="Turbo_Pascal" title="Turbo Pascal">Turbo Pascal</a>, später <a href="Object_Pascal" title="Object Pascal">Object Pascal</a>. Jene sind, gegenüber dem Ur-Pascal, wesentlich erweiterte Versionen.
</p><p>Ein wichtiges Konzept der Fehlersicherheit, das Wirth zur Anwendung brachte, ist die <a href="Starke_Typisierung" title="Starke Typisierung">starke Typisierung</a> (englisch „strong typing“): <a href="Variable_(Programmierung)" title="Variable (Programmierung)">Variablen</a> sind bereits zur Übersetzungszeit einem bestimmten <a href="Datentyp" title="Datentyp">Datentyp</a> zugeordnet, und dieser kann nicht nachträglich verändert werden. Typenstrenge bedeutet, dass Wertzuweisungen ausschließlich unter Variablen gleichen Typs erlaubt sind. In Pascal gibt es von diesem strikten Zwang lediglich wenige Ausnahmen:
</p>
<ul><li>Wertzuweisungen der Form [Variable vom Typ <code>real</code>] <code>:=</code> [Wert vom Typ <code>integer</code>].</li>
<li>In Extended-Pascal Wertzuweisungen von ganzzahligen oder reellen Zahlen an Variablen vom Typ <code>complex</code>.</li>
<li>Wertzuweisungen von eingeschränkten Wertebereichen eines <a href="Ordinaler_Datentyp" class="mw-redirect" title="Ordinaler Datentyp">ordinalen Typs</a>. Beispiel: <code>type int10 = 1 .. 10;</code> Werte dieses Typs können dann Integervariablen zugewiesen werden.</li>
<li>Wertzuweisungen von Mengen eines eingeschränkten Wertebereiches eines ordinalen Typs. Beispiel: <code>type set10 = set of 1 .. 10; set20 = set of 1 .. 20;</code> Werte des Typs <code>set10</code> können dann Variablen des Typs <code>set20</code> zugewiesen werden.</li>
<li>Wertzuweisungen auf eingeschränkte Wertebereiche eines ordinalen Typs oder einer Menge. In diesem Fall rufen Werte bzw. Mengen-Elemente außerhalb des Zielbereichs einen <a href="Laufzeitfehler" title="Laufzeitfehler">Laufzeitfehler</a> hervor.</li>
<li>Wertzuweisungen zwischen unterschiedlichen String-Typen, inkl. <code>char</code>, Zeichen-<a href="Array_(Datentyp)" title="Array (Datentyp)">Arrays</a> gemäß Standard-Pascal und den verschiedenen <code>String</code>-Typen in Extended-Pascal, Borland Pascal usw. Sofern die Länge des Wertes nicht innerhalb der Kapazität des Ziels liegt, ergibt sich auch hier ein Laufzeitfehler.</li></ul>
<p>Heute findet Pascal noch im universitären Bereich (Entwicklung/Ausbildung) und in sicherheitskritischen Bereichen (z.&nbsp;B. <a href="Verkehrstechnik" title="Verkehrstechnik">Verkehrstechnik</a>, <a href="Energieversorgung" title="Energieversorgung">Energieversorgung</a>, <a href="Medizintechnik" title="Medizintechnik">Medizintechnik</a>, <a href="Raumfahrt" title="Raumfahrt">Raumfahrt</a>, <a href="Milit%C3%A4r" title="Militär">Militär</a>, teilweise im <a href="Bankensystem" title="Bankensystem">Banken-</a> und <a href="Versicherungswesen" class="mw-redirect" title="Versicherungswesen">Versicherungswesen</a>) Anwendung. Dies beruht hauptsächlich auf der guten Prüfbarkeit und <a href="Wartbarkeit" title="Wartbarkeit">Wartbarkeit</a> des Codes und der klaren Zuordnung der Variablen. So war die 2005 eingeführte <a href="Betriebsleittechnik" title="Betriebsleittechnik">Betriebsleittechnik</a>&nbsp;IV der 2011 stillgelegten <a href="Transrapid-Versuchsanlage_Emsland" title="Transrapid-Versuchsanlage Emsland">Transrapid-Versuchsanlage Emsland</a> in Pascal programmiert.
Eine pascalähnliche Notation wurde in der Informatik und Mathematik zur Darstellung von Algorithmen benutzt.<sup id="cite_ref-2" class="reference"><a href="#cite_note-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup> Aus didaktischen Gründen, es seien hier die Typstrenge, Fehlersicherheit und frei verfügbare portierbare Pascalcompiler (<a href="Free_Pascal" title="Free Pascal">Free Pascal</a>, <a href="GNU_Pascal" title="GNU Pascal">GNU Pascal</a>) genannt, wird im aktuellen Informatikunterricht Pascal ebenfalls noch eingesetzt.<sup id="cite_ref-3" class="reference"><a href="#cite_note-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup> Im Hobby-Bereich erlangte Pascal zeitweilig eine weite Verbreitung.<sup id="cite_ref-4" class="reference"><a href="#cite_note-4"><span class="cite-bracket">[</span>4<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading2"><h2 id="Syntax">Syntax</h2></div>
<div class="mw-heading mw-heading3"><h3 id="Hallo_Welt">Hallo Welt</h3></div>
<p>Ein <a href="Hallo-Welt-Programm" title="Hallo-Welt-Programm">Hallo-Welt-Programm</a> sieht <a href="Liste_von_Hallo-Welt-Programmen/Programmiersprachen#Pascal" class="mw-redirect" title="Liste von Hallo-Welt-Programmen/Programmiersprachen">in Pascal</a> folgendermaßen aus:
</p>
<div class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" dir="ltr"><pre><span></span><span class="w"> </span><span class="k">program</span><span class="w"> </span><span class="n">Hallo</span><span class="p">(</span><span class="n">output</span><span class="p">)</span><span class="o">;</span>
<span class="w"> </span><span class="k">begin</span>
<span class="w"> </span><span class="nb">writeln</span><span class="p">(</span><span class="s">'Hallo Welt'</span><span class="p">)</span>
<span class="w"> </span><span class="k">end</span><span class="o">.</span>
</pre></div>
<p>In der Pascal-Version, die im 1973 erschienenen <i>Revised Report</i> beschrieben wird, sind die <a href="Textdatei" title="Textdatei">Textdateien</a> <code>input</code> und <code>output</code> vordefinierte Programmparameter.
Sie als Programmparameter aufzuführen ist (in <i>dieser</i> Pascal-Version jedenfalls) ausdrücklich verboten.<sup id="cite_ref-RR_5-0" class="reference"><a href="#cite_note-RR-5"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup>
Daher ist das folgende Programm äquivalent zum obigen.
In Dialekten wie Delphi wird der Programmkopf (nahezu) ignoriert und kann komplett entfallen, falls er jedoch vorhanden ist, muss er <i>syntaktisch</i> korrekt sein.
</p>
<div class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" dir="ltr"><pre><span></span><span class="w"> </span><span class="k">program</span><span class="w"> </span><span class="n">Hallo</span><span class="o">;</span>
<span class="w"> </span><span class="k">begin</span>
<span class="w"> </span><span class="nb">writeln</span><span class="p">(</span><span class="s">'Hallo Welt'</span><span class="p">)</span>
<span class="w"> </span><span class="k">end</span><span class="o">.</span>
</pre></div>
<p>Ein Detail am Rande: In manchen alten Beispielen findet man ein <code>readln</code> nach dem <code>writeln</code>-Befehl. Das war nur notwendig, weil die I/O-Architektur der <a href="Control_Data_Corporation" title="Control Data Corporation">CDC Cyber 6000</a>, auf der Wirth den ersten Pascal-Compiler entwickelte, das benötigte, um die internen Puffer zu leeren – sonst wäre im interaktiven Betrieb keine Ausgabe zu sehen gewesen. IDEs (<a href="Integrierte_Entwicklungsumgebung" title="Integrierte Entwicklungsumgebung">integrierte Entwicklungsumgebungen</a>) konnte man mit diesem <code>readln</code> zwingen, am Ende der Programmausführung nicht sofort wieder in den Editor-Modus umzuschalten, was die Ausgabe bei manchen IDEs (z.&nbsp;B. Turbo-Pascal) sonst hätte verschwinden lassen. Im <a href="Stapelverarbeitung" title="Stapelverarbeitung">Batch-Betrieb</a> war das ohnehin nie notwendig.
</p>
<div class="mw-heading mw-heading3"><h3 id="Datentypen">Datentypen</h3></div>
<div class="mw-heading mw-heading4"><h4 id="Standarddatenypen">Standarddatenypen</h4></div>
<table class="wikitable sortable; float-right">

<tbody><tr>
<th>Datentyp
</th>
<th>Werte
</th></tr>
<tr>
<td><a href="Integer_(Datentyp)" title="Integer (Datentyp)">integer</a>
</td>
<td><a href="Ganze_Zahl" title="Ganze Zahl">Ganze Zahlen</a>, etwa <code>4</code>, <code>0</code> oder <code>-17</code>
</td></tr>
<tr>
<td>real
</td>
<td><a href="Gleitkommazahl" title="Gleitkommazahl">Gleitkommazahlen</a>, etwa <code>0.4</code> oder <code>-17.74445</code>
</td></tr>
<tr>
<td><a href="Boolesche_Variable" class="mw-redirect" title="Boolesche Variable">boolean</a>
</td>
<td>die Werte <code>true</code> und <code>false</code>
</td></tr>
<tr>
<td><a href="Char_(Datentyp)" title="Char (Datentyp)">char</a>
</td>
<td>ein einzelnes Zeichen, etwa <code>a</code> oder <code>f</code>
</td></tr></tbody></table>
<p>Jeder Variablen muss in einer Variablendeklaration ein Datentyp zugeordnet werden. Der Datentyp bestimmt, welche möglichen Werte die Variable während des Programmablaufs speichern kann. In Pascal gibt es vier einfache Standardtypen, nämlich <code>integer</code>, <code>real</code>, <code>boolean</code> und <code>char</code>.
</p><p>Die Längen der verschiedenen Datentypen außer <code>boolean</code> sind abhängig vom Compiler. Weiterhin haben viele Implementationen noch weitere vordefinierte einfache Datentypen.
</p>
<div class="mw-heading mw-heading4"><h4 id="Selbstdefinierte_Datentypen">Selbstdefinierte Datentypen</h4></div>
<p>In Pascal ist es möglich, neben den vier Standardtypen eigene einfache Datentypen zu definieren. Dabei handelt es sich entweder um <a href="Aufz%C3%A4hlungstyp" title="Aufzählungstyp">Aufzählungstypen</a> oder Ausschnittstypen. Um einen neuen Aufzählungstyp zu definieren, schreibt man alle Werte, die eine Variable dieses Typs speichern können soll, der Reihe nach auf. Im folgenden Beispiel wird ein neuer Typ mit dem Namen <code>Besteck</code> definiert: <code>Besteck = (Gabel, Messer, Loeffel)</code>
</p><p>Einen Ausschnittstyp definiert man, wenn der Wertebereich eines umfassenderen Typs nicht voll ausgeschöpft wird. Wenn eine Variable beispielsweise nur die Zahlen zwischen 0 und 255 speichern können soll, so ist es möglich, den Datentyp <code>integer</code> auf diese <a href="Teilmenge" title="Teilmenge">Teilmenge</a> einzuschränken. Im folgenden Beispiel wird ein neuer Typ mit dem Namen <code>byte</code> definiert: <code>byte = 0 .. 255;</code>
</p>
<div class="mw-heading mw-heading4"><h4 id="Strukturierte_Datentypen">Strukturierte Datentypen</h4></div>
<p>Pascal bietet Programmierern vier strukturierte Datentypen, die es ermöglichen, mehrere Werte in einer Variablen zu speichern. In einem <a href="Feld_(Datentyp)" class="mw-redirect" title="Feld (Datentyp)">Feld</a> (<i>array</i>) kann eine feste, also während der <a href="Laufzeit_(Informatik)" title="Laufzeit (Informatik)">Laufzeit</a> unveränderbare Anzahl von Werten gespeichert werden, die alle vom selben Datentyp sein müssen. Im folgenden Beispiel wird ein Feld definiert, in dem maximal 100 ganze Zahlen abgespeichert werden können:
</p>
<div class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" dir="ltr"><pre><span></span><span class="n">BeispielFeld</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">array</span><span class="w"> </span><span class="p">[</span><span class="mi">1</span><span class="o">..</span><span class="mi">100</span><span class="p">]</span><span class="w"> </span><span class="k">of</span><span class="w"> </span><span class="kt">integer</span><span class="o">;</span>
</pre></div>
<p>In einer Menge (<i>set</i>) können ebenfalls Werte vom selben Datentyp gespeichert werden, allerdings wird nur festgehalten, welche Werte in der Menge enthalten sind, wobei es nicht darauf ankommt, wie oft ein einzelner Wert genannt wurde oder in welcher Reihenfolge die Werte genannt wurden. Ein Beispiel für die Definition einer Menge:
</p>
<div class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" dir="ltr"><pre><span></span><span class="n">BeispielMenge</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">set</span><span class="w"> </span><span class="k">of</span><span class="w"> </span><span class="mi">13</span><span class="o">..</span><span class="mi">55</span><span class="o">;</span>
</pre></div>
<p>In einem <a href="Verbund_(Datentyp)" title="Verbund (Datentyp)">Verbund</a> (<i>record</i>) kann eine feste Anzahl von Werten gespeichert werden, wobei die Werte von verschiedenem Datentyp sein dürfen. Ein Beispiel einer Definition:
</p>
<div class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" dir="ltr"><pre><span></span><span class="n">Person</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">record</span>
<span class="w"> </span><span class="n">Alter</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="mi">0</span><span class="o">..</span><span class="mi">150</span><span class="o">;</span>
<span class="w"> </span><span class="n">Haarfarbe</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="p">(</span><span class="n">braun</span><span class="o">,</span><span class="w"> </span><span class="n">blond</span><span class="o">,</span><span class="w"> </span><span class="n">schwarz</span><span class="p">)</span><span class="o">;</span>
<span class="w"> </span><span class="n">Groesse</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="kt">real</span><span class="o">;</span>
<span class="w"> </span><span class="n">kurzsichtig</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="kt">boolean</span>
<span class="k">end</span><span class="o">;</span>
</pre></div><p>
Eine beliebig lange Folge von Werten desselben Typs kann in Pascal mithilfe des Datentyps <code>file</code> (<span style="font-style:normal;font-weight:normal"><a href="Deutsche_Sprache" title="Deutsche Sprache">deutsch</a></span> <span lang="de-Latn">Datei</span>) dargestellt werden. Beispiel einer Definition: </p><div class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" dir="ltr"><pre><span></span><span class="n">BeispielDatei</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">file</span><span class="w"> </span><span class="k">of</span><span class="w"> </span><span class="kt">integer</span>
</pre></div>
<div class="mw-heading mw-heading4"><h4 id="Zeiger">Zeiger</h4></div>
<p>Hauptzweck der Verwendung von <a href="Zeiger_(Informatik)" title="Zeiger (Informatik)">Zeigern</a> ist in Pascal das Erstellen von verschiedenen Datenstrukturen, je nach den Vorstellungen des Programmierers. So lassen sich mithilfe von Zeigern etwa <a href="Liste_(Datenstruktur)" title="Liste (Datenstruktur)">Listen</a> und <a href="Baum_(Datenstruktur)" title="Baum (Datenstruktur)">Bäume</a> erstellen, die bei der Speicherung von Daten Vorteile gegenüber Feldern, Mengen, Verbünden und Dateien bieten. Ein weiterer Vorteil von Zeigern ist, dass Zeigervariablen den von ihnen benötigten Speicherplatz während der Laufzeit anfordern können. Der Programmierer muss also nicht schon im Vorhinein definieren, wie viel Platz die Variablen seines Programms bei der Ausführung benötigen werden und kann grundsätzlich vom Minimum ausgehen, über das, je nach Bedarfsfall, hinaus erweitert wird.
</p>
<div class="mw-heading mw-heading3"><h3 id="Programmstrukturen">Programmstrukturen</h3></div>
<p>Charakteristisch für Pascal ist das Konzept der Verschachtelung von <a href="Prozedur_(Programmierung)" title="Prozedur (Programmierung)">Prozeduren</a> und <a href="Funktion_(Programmierung)" title="Funktion (Programmierung)">Funktionen</a>. Im Deklarationsteil einer Prozedur oder Funktion können andere Prozeduren und Funktionen definiert werden, die außerhalb nicht sichtbar sind. Beispiel:
</p>
<div class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" dir="ltr"><pre><span></span><span class="k">program</span><span class="w"> </span><span class="n">HalloWelt</span><span class="o">;</span>
<span class="w"> </span><span class="k">procedure</span><span class="w"> </span><span class="nf">foo</span><span class="o">;</span>
<span class="w"> </span><span class="k">procedure</span><span class="w"> </span><span class="nf">bar</span><span class="o">;</span>
<span class="w"> </span><span class="k">begin</span>
<span class="w"> </span><span class="nb">writeln</span><span class="p">(</span><span class="s">'Hallo Welt'</span><span class="p">)</span><span class="o">;</span>
<span class="w"> </span><span class="k">end</span><span class="o">;</span>
<span class="w"> </span><span class="k">begin</span>
<span class="w"> </span><span class="n">bar</span>
<span class="w"> </span><span class="k">end</span><span class="o">;</span>
<span class="k">begin</span>
<span class="w"> </span><span class="n">foo</span><span class="o">;</span><span class="w"> </span><span class="cm">(* kein Compilerfehler *)</span>
<span class="w"> </span><span class="n">bar</span><span class="w"> </span><span class="cm">(* Compilerfehler, da bar nicht sichtbar *)</span>
<span class="k">end</span><span class="o">.</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Kontrollstrukturen">Kontrollstrukturen</h3></div>
<div class="mw-heading mw-heading4"><h4 id="Bedingte_Anweisung_und_Verzweigung">Bedingte Anweisung und Verzweigung</h4></div>
<p>Als <a href="Bedingte_Anweisung_und_Verzweigung" title="Bedingte Anweisung und Verzweigung">bedingte Anweisungen und Verzweigungen</a> stehen in Pascal die <code>if</code>- und die <code>case</code>-Anweisung zur Verfügung. Ein Beispiel einer <code>if</code>-Verzweigung:
</p>
<div class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" dir="ltr"><pre><span></span><span class="k">if</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">2</span><span class="w"> </span><span class="k">then</span>
<span class="w"> </span><span class="nb">writeln</span><span class="w"> </span><span class="p">(</span><span class="s">'wird nicht ausgeführt'</span><span class="p">)</span>
<span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="k">then</span>
<span class="w"> </span><span class="nb">writeln</span><span class="w"> </span><span class="p">(</span><span class="s">'wird ausgeführt'</span><span class="p">)</span>
<span class="k">else</span>
<span class="w"> </span><span class="nb">writeln</span><span class="w"> </span><span class="p">(</span><span class="s">'wird nicht ausgeführt'</span><span class="p">)</span><span class="o">;</span>
</pre></div>
<div class="mw-heading mw-heading4"><h4 id="Schleifen">Schleifen</h4></div>
<p>Pascal bietet drei Arten von <a href="Schleife_(Programmierung)" title="Schleife (Programmierung)">Schleifen</a>. Soll vor jedem Schleifendurchlauf eine <a href="Abbruchbedingung" title="Abbruchbedingung">Abbruchbedingung</a> geprüft werden, verwendet man die <code>while</code>-Anweisung, für eine Prüfung nach jedem Durchlauf die <code>repeat</code>-Anweisung. Für eine vorgegebene Anzahl von Durchläufen gibt es die <code>for</code>-Anweisung.
</p>
<div class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" dir="ltr"><pre><span></span><span class="k">while</span><span class="w"> </span><span class="n">wert</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="mi">100</span><span class="w"> </span><span class="k">do</span>
<span class="w"> </span><span class="n">wert</span><span class="w"> </span><span class="o">:=</span><span class="w"> </span><span class="n">wert</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="o">;</span>
</pre></div>
<div class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" dir="ltr"><pre><span></span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="o">:=</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="k">to</span><span class="w"> </span><span class="mi">100</span><span class="w"> </span><span class="k">do</span>
<span class="w"> </span><span class="n">wert</span><span class="w"> </span><span class="o">:=</span><span class="w"> </span><span class="n">wert</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="o">;</span>
</pre></div>
<div class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" dir="ltr"><pre><span></span><span class="k">repeat</span>
<span class="w"> </span><span class="n">wert</span><span class="w"> </span><span class="o">:=</span><span class="w"> </span><span class="n">wert</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>
<span class="k">until</span><span class="w"> </span><span class="n">wert</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="mi">100</span><span class="o">;</span>
</pre></div>
<p>Die <code>with</code>-Anweisung ist keine Schleife, sie vereinfacht nur die Zugriffe auf Komponenten eines Record.
</p><p><a href="Sprunganweisung" title="Sprunganweisung">Sprunganweisungen</a> können mit <code>goto</code> auch verwendet werden, dessen Gebrauch jedoch umstritten ist (siehe Artikel zu Sprunganweisungen).
</p>
<div class="mw-heading mw-heading2"><h2 id="Compiler">Compiler</h2></div>
<p>Pascal-Compiler sind überwiegend <i><a href="Single-Pass-Compiler" class="mw-redirect" title="Single-Pass-Compiler">Single-Pass-Compiler</a></i>, d.&nbsp;h. die Quelle wird nur ein einziges Mal gelesen und <a href="Lexikalische_Analyse" title="Lexikalische Analyse">analysiert</a>. Das Design der Sprache war so gehalten, um genau das zu ermöglichen. Bei der damaligen geringen Geschwindigkeit der Rechner Anfang der 1970er Jahre war dies ein großer Vorteil.
</p><p>Der erste Pascal-<a href="Compiler" title="Compiler">Compiler</a> entstand auf der <a href="CDC_6600" title="CDC 6600">CDC Cyber 6000</a> der <a href="Eidgen%C3%B6ssische_Technische_Hochschule_Z%C3%BCrich" class="mw-redirect" title="Eidgenössische Technische Hochschule Zürich">ETH Zürich</a>. Daraus entstand dann Pascal 6000, das als erste operative Version eines Compilers der Sprache gesehen werden kann.
</p><p>Ein zweiter Pascal-Compiler – der P4 „Portable Pascal Compiler“ von Urs Ammann, Kesav Nori und Christian Jacobi – stammte ebenfalls von der ETH Zürich. Der P4 erzeugte eine plattformunabhängige, als <a href="Assemblersprache" title="Assemblersprache">Assemblersprache</a> ausgelegte Zwischensprache, den <b><a href="P-Code" title="P-Code">P-Code</a></b>, der durch eine <a href="Virtuelle_Maschine" title="Virtuelle Maschine">virtuelle Maschine</a> (ein Programm) interpretiert wird. Später entstanden dann Compiler, die auf dem P4 basierten. Die verbreitetste Version wurde unter dem Namen <b><a href="UCSD_Pascal" title="UCSD Pascal">UCSD Pascal</a></b> bekannt, das auf vielen Systemen implementiert wurde, u.&nbsp;a. auf <a href="Apple_II" title="Apple II">Apple II</a> und <a href="Texas_Instruments_TI-99/4A" title="Texas Instruments TI-99/4A">Texas Instruments TI-99/4A</a> und wesentlich zur Verbreitung der Sprache sowohl (zuerst) in den <a href="Vereinigte_Staaten" title="Vereinigte Staaten">Vereinigten Staaten</a>, später auch in <a href="Europa" title="Europa">Europa</a> beitrug. Im Mai 2006 wurden die <a href="Quelltext" title="Quelltext">Quelltexte</a> von Version II.0 freigegeben.
</p>
<div class="mw-heading mw-heading2"><h2 id="Besonderheiten">Besonderheiten</h2></div>
<p><b>Sehr hohe Prozesssicherheit</b>
</p><p>Da Pascal sowie der Quasi-Standard Borland/Turbo-Pascal eine strikte Trennung unterschiedlicher Typen vorsehen und die <a href="Zuweisungskompatibilit%C3%A4t" title="Zuweisungskompatibilität">Zuweisungskompatibilität</a> von Ausdrücken beachten, kommen implizite <a href="Typumwandlung" title="Typumwandlung">Typumwandlungen</a>, anders als in C, praktisch nicht vor. Insbesondere bei der Übergabe von Daten (z.&nbsp;B. aus externen Dateien, aber auch innerhalb des Programms) an Funktionen oder Prozeduren kann der Compiler schon beim Kompilieren die Korrektheit der Typen kontrollieren.
</p><p><b>Keine nullterminierten Zeichenketten</b>
</p><p>Standard Pascal hatte zwar Zeichenketten-<a href="Literal" title="Literal">Literale</a>, aber keinen Typ <code>string</code> (s.&nbsp;oben). In den meisten späteren Implementierungen wurden Zeichenketten als <code>char</code>-Arrays definiert, bei denen das erste Feld (Byte) zur Speicherung der Länge verwendet wurde. Daraus ergab sich eine Längenbegrenzung von 255 Zeichen. Bei den in der <a href="C-Standard-Bibliothek" title="C-Standard-Bibliothek">C-Standard-Bibliothek</a> verwendeten Strings handelt es sich dagegen um NUL-terminierte Strings. Durch die Längenspeicherung in Pascal können verschiedene Operationen wie Stringverkettung effizienter durchgeführt werden (kein Durchsuchen bis zum <a href="NUL-Zeichen" class="mw-redirect" title="NUL-Zeichen">NUL-Zeichen</a> erforderlich). Größere Zeichenketten mussten selbst definiert werden (z.&nbsp;B. als <i>Array of char</i>), sofern sie nicht (wie z.&nbsp;B. in Borland Pascal 7) durch die Compilerhersteller bereits implementiert wurden. Im Extended-Pascal-Standard wurden Zeichenketten als Scheme-Typ definiert. Auch hier muss die Kapazität angegeben werden, sie wird aber in runde Klammern geschrieben, und es gibt keine formale Längenbeschränkung: <code>string(10240)</code>.
</p><p><b>Strikte Trennung zwischen Programm, Funktionen und Prozeduren</b>
</p><p>Pascal trennt strikt zwischen einer Funktion (mit Rückgabewert) und einer Prozedur (kein Rückgabewert). Eine Funktion darf nicht als Prozedur aufgerufen werden – d.&nbsp;h., der Rückgabewert muss stets entgegengenommen werden. Seit Turbo Pascal 4.0 (1987) ist es jedoch möglich, Funktionen auch ohne Entgegennahme des Funktionsergebnisses aufzurufen. Weiterhin wird ein ausführbares Programm in Pascal durch das <a href="Schl%C3%BCsselwort_(Programmierung)" title="Schlüsselwort (Programmierung)">Schlüsselwort</a> <code>program</code> gekennzeichnet, wohingegen in C der Einstiegspunkt für ein Programm die Funktion <code>main</code> ist, die sich außer durch ihren Namen nicht von anderen Funktionen unterscheidet.
</p><p><b>Deklarationen</b>
</p><p>Programme, Funktionen und Prozeduren sind im Gegensatz zu <a href="C_(Programmiersprache)" title="C (Programmiersprache)">C</a> dreigegliedert: Es gibt neben dem Kopfteil, der den Namen und die <a href="Signatur_(Programmierung)" title="Signatur (Programmierung)">Signatur</a> enthält, einen separaten Deklarationsteil, in dem Typen, Variablen und verschachtelte Prozeduren/Funktionen deklariert werden und einen Definitionsteil, in dem implementiert wird. In C gibt es nur einen Funktionskopf und Funktionsrumpf, der den Deklarations- und Definitionsteil vereinigt. In C dürfen Funktionen nicht verschachtelt definiert werden.
</p><p><b>Case sensitivity</b>
</p><p>Im Gegensatz zu C ist Pascal in Bezug auf Schlüsselwörter, <a href="Bezeichner" title="Bezeichner">Bezeichner</a> von Variablen, Funktionen oder Prozeduren <i><a href="Case_sensitivity" title="Case sensitivity">case-insensitive</a></i>.
</p><p><b>Semikolon</b>
</p><p>Das Semikolon wird nicht wie in C als Befehlsabschluss interpretiert, sondern als <a href="Trennzeichen" title="Trennzeichen">Trennzeichen</a> zwischen Anweisungen. Vor einem <code>end</code> oder <code>until</code> kann es somit weggelassen werden. Vor einem <code>else</code> darf es in der Regel gar nicht stehen, da sonst der <code>if</code>-Zweig als abgeschlossen angesehen werden würde. Ein Fall, bei dem es vor dem <code>else</code> steht (und stehen muss), ist am Ende einer <code>case</code>-Auflistung.
</p><p><b>Delimiter</b>
</p><p>Für Zeichenketten-Literale und Zeichen-Literale wird dasselbe Begrenzungszeichen (Delimiter), nämlich der Apostroph, verwendet.
</p><p><b>Zuweisungen</b>
</p><p>Zuweisungen an Variablen werden durch die Sequenz <code>:=</code> definiert, das <a href="Gleichheitszeichen" title="Gleichheitszeichen">Gleichheitszeichen</a> allein dient dem Gleichheitsvergleich und der Definition von <a href="Konstante_(Programmierung)" title="Konstante (Programmierung)">Konstanten</a>. Damit werden „mathematisch falsche“ Ausdrücke, z.&nbsp;B. <code>i = i + 1</code>, vermieden. Verkürzte Schreibweisen für Zuweisungen wie <code>i++</code> statt <code>i&nbsp;:= i + 1</code> oder <code>i *= 2</code> statt <code>i&nbsp;:= 2 * i</code> existieren in Pascal nicht. Für <code>i++</code> sieht Pascal die <a href="Intrinsische_Funktion" title="Intrinsische Funktion">intrinsische Funktion</a> <code>inc(i)</code> und für <code>i--</code> die Funktion <code>dec(i)</code> vor, die bei einigen Dialekten mächtiger sind als ein <a href="Einstellige_Verkn%C3%BCpfung" title="Einstellige Verknüpfung">unärer</a> Postfix- oder Präfix-<a href="Operator_(Mathematik)" title="Operator (Mathematik)">Operator</a>.<sup id="cite_ref-6" class="reference"><a href="#cite_note-6"><span class="cite-bracket">[</span>6<span class="cite-bracket">]</span></a></sup>
</p><p><b>Operatoren</b>
</p><p>Pascal verwendet die Operatoren <code>and</code>, <code>or</code>, <code>not</code>, <code>div</code> (nur für <i>Integer</i>, bei <i>Real</i> ist es <code>/</code>), <code>mod</code> und <code>&lt;&gt;</code> anstatt der C-Operatoren <code>&amp;&amp;</code>, <code>||</code>, <code>!</code>, <code>/</code>, <code>%</code> und <code>!=</code>. Die „Short Circuit“-Funktionalität von <code>&amp;&amp;</code> und <code>||</code> in C (sobald das Ergebnis feststeht, nämlich wenn der linke Teil beim <code>and</code> FALSE beziehungsweise beim <code>or</code> TRUE ist, wird der rechte nicht mehr ausgewertet) schloss Niklaus Wirth explizit aus, da compilerinterne Optimierungsvorgänge die Reihenfolge der Auswertung verändern können. Spätere Pascalversionen implementierten eine lokal oder global zuschaltbare „Short Circuit“-Funktionalität, so dass der Programmierer im Einzelfall entscheiden kann, welche Art der Auswertung er wünscht. In Standard-Pascal gibt es keine Bitoperationen für <i>Integer</i> (wie <code>&amp;</code>, <code>|</code>, <code>^</code> und <code>~</code> von C), aber stattdessen den Typ <code>set of</code> (mit den Operatoren <code>*</code>, <code>+</code> und <code>-</code> für Durchschnitt, Vereinigung und Mengendifferenz).
</p><p><b>Strenge Typentrennung</b>
</p><p>Pascal betreibt strenge Typentrennung, sodass unter anderem der Typ <code>char</code> nicht austauschbar ist mit <code>integer</code>. Die Umwandlung muss mit den Funktionen <code>ord()</code> und <code>chr()</code> durchgeführt werden. Dadurch werden verdeckte (oder ungewollte) Umwandlungen vermieden; z.&nbsp;B. führt die Anweisung <code>i&nbsp;:= 7/2</code> (mit i als <code>integer</code>) zu einer Fehlermeldung, weil der Operator / ein Operator ist, der <code>real</code> als Ergebnis hat. Spätere Pascalversionen (z.&nbsp;B. Turbo Pascal) führten zusätzlich „explizite“ <a href="Typumwandlung" title="Typumwandlung">Typumwandlungen</a>, sog. „type casts“, ein, so dass z.&nbsp;B. mit <code>longint(i)</code> der Wertebereich der Ganzzahlvariablen i erweitert oder eingeschränkt werden konnte. In Standard-Pascal musste dafür ein Umweg über (den Missbrauch von) Variantenrecords (<code>union</code> in C) genommen werden.
</p><p><b>Zeigerarithmetik</b>
</p><p>In Pascal existiert keine Zeigerarithmetik, Iterationen über Arrays können nur über den Index erfolgen.
</p>
<div class="mw-heading mw-heading2"><h2 id="Standards">Standards</h2></div>
<p>Wirths erste Veröffentlichung der neuen Programmiersprache erschien 1971, eine überarbeitete und erweiterte Version dieses Berichts 1973. Ein weiteres Jahr später folgte ein mit Kathleen Jensen geschriebener Bericht,<sup id="cite_ref-7" class="reference"><a href="#cite_note-7"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup> den Wirth als ultimative Referenz für Programmierer und Implementoren bezeichnete; das darin beschriebene Pascal nannte er Standard Pascal.<sup id="cite_ref-8" class="reference"><a href="#cite_note-8"><span class="cite-bracket">[</span>8<span class="cite-bracket">]</span></a></sup>
</p><p>Es gibt drei Standards, die sich auf Pascal beziehen:
</p>
<ol><li>Standard Pascal: ANSI/IEEE770X3.97-1993 oder ISO 7185:1990;</li>
<li>Extended Pascal: ANSI/IEEE770X3.160-1989 oder ISO/IEC 10206:1991;</li>
<li>sowie einen Entwurf zu „Object-Oriented Extensions to Pascal“.</li></ol>
<p>Allerdings sind – wie bei den meisten anderen Programmiersprachen auch – nur die wenigsten Compiler zu diesen Standards vollständig kompatibel. Diese Tatsache verleitete Scott A. Moore zu der bissigen Bemerkung „Pascal is, unfortunately, very much a great improvement on its successors“ („Pascal ist leider so ziemlich eine große Verbesserung seiner Nachfolger“ – damals bereits ein geflügelter Satz).
</p><p>Selbst großen Compilern wie <a href="Embarcadero_Delphi" title="Embarcadero Delphi">Delphi</a> oder <a href="Free_Pascal" title="Free Pascal">Free Pascal</a> fehlen bis heute einige Elemente aus Standard Pascal, während Extended Pascal von kaum einem unterstützt wird. Lediglich Prospero Pascal ist vollständig kompatibel zu Extended Pascal, während auch GNU Pascal vollständige Kompatibilität anstrebt.
</p>
<div class="mw-heading mw-heading2"><h2 id="Pascal_und_Mac_OS">Pascal und Mac OS</h2></div>
<p>Historisch interessant ist die Tatsache, dass <a href="Apple" title="Apple">Apple</a> bei der Entwicklung des <a href="Betriebssystem" title="Betriebssystem">Betriebssystems</a> und der darauf laufenden <a href="Anwendungssoftware" title="Anwendungssoftware">Applikationen</a> des Apple-II-Nachfolgers <a href="Apple_Macintosh" class="mw-redirect" title="Apple Macintosh">Macintosh</a> auf Pascal gesetzt hatte. Hierzu wurde bei Apple in einem von <a href="Larry_Tesler" title="Larry Tesler">Larry Tesler</a> geführten Team unter Konsultation von Niklaus Wirth eine eigene Object-Pascal-Variante entwickelt, die von einer früheren objektorientierten Pascal-Variante namens Clascal abgeleitet wurde, die schon auf <a href="Apple_Lisa" title="Apple Lisa">Lisa</a> verfügbar war. Object Pascal war für die Unterstützung von MacApp, einem Macintosh Application Framework erforderlich, das heute unter den Begriff <a href="Klassenbibliothek" class="mw-redirect" title="Klassenbibliothek">Klassenbibliothek</a> fallen würde. Object Pascal wurde 1986 fertiggestellt. Apple beendete den Fokus auf Object Pascal mit der Umstellung von <a href="Motorola-68000er-Familie" title="Motorola-68000er-Familie">Motorola 68K</a>-CPUs auf <a href="PowerPC" title="PowerPC">PowerPC</a>-CPUs von IBM im Jahr 1994 mit der Betriebssystem-Version <a href="Mac_OS_7" class="mw-redirect" title="Mac OS 7">Mac OS 7.5</a>. Zwecks <a href="R%C3%BCckw%C3%A4rtskompatibilit%C3%A4t" class="mw-redirect" title="Rückwärtskompatibilität">Rückwärtskompatibilität</a> blieb die Übergabe von Parametern für Betriebssystemaufrufe bis <a href="Mac_OS_9" title="Mac OS 9">Mac OS 9.2.2</a> (veröffentlicht im Dezember 2001) an Pascal-Konventionen angelehnt.
</p>
<div class="mw-heading mw-heading2"><h2 id="Implementierungen_(Compiler,_Interpreter_und_IDEs)"><span id="Implementierungen_.28Compiler.2C_Interpreter_und_IDEs.29"></span>Implementierungen (Compiler, Interpreter und IDEs)</h2></div>
<p>Pascal hatte von Anfang an im universitären Bereich sehr großen Erfolg, was sich u.&nbsp;a. auch in der Programmiersprache <a href="Ada_(Programmiersprache)" title="Ada (Programmiersprache)">Ada</a> niederschlug, die sehr stark an der Syntax von Pascal angelehnt ist. Ebenfalls fand es weite Verbreitung, auch im kommerziellen Bereich, mit den Produkten der Firma <a href="Borland" title="Borland">Borland</a> <a href="Turbo_Pascal" title="Turbo Pascal">Turbo Pascal</a>, Borland Pascal und Delphi. Diese Versionen sind durch starke Erweiterungen des ursprünglichen Sprachstandards gekennzeichnet. Die Objektorientierung wurde dabei mit Version 5.5 eingeführt.
</p>
<div class="mw-heading mw-heading3"><h3 id="Freie_Implementierungen">Freie Implementierungen</h3></div>
<dl><dt><a href="UCSD_Pascal" title="UCSD Pascal">UCSD Pascal</a></dt>
<dd>Eine Pascal-Implementierung der <a href="University_of_California" title="University of California">University of California</a>, San Diego (UCSD).</dd>
<dt><a href="Free_Pascal" title="Free Pascal">Free Pascal</a></dt>
<dd>Ein unter der <a href="GNU_Lesser_General_Public_License" title="GNU Lesser General Public License">GNU Lesser General Public License</a> stehendes <a href="Open_Source" title="Open Source">Open-Source</a>-Projekt, das sich zum Ziel gesetzt hat, einen freien 32/64-Bit-Compiler zu erzeugen, der 100-prozentig kompatibel zu Turbo Pascal und Delphi sein soll und mittlerweile eine leichte Portierung von Pascal-Programmen auf fast alle gängigen Betriebssysteme und Hardwareplattformen ermöglicht.</dd>
<dt><a href="GNU_Pascal" title="GNU Pascal">GNU Pascal</a> (GPC)</dt>
<dd>Ein Pascal-Compiler, der als Frontend zur <a href="GNU_Compiler_Collection" title="GNU Compiler Collection">GNU Compiler Collection</a> konzipiert ist. Er ist kein Bestandteil der GCC selbst, ist aber durch die Verwendung der GCC plattformunabhängig. GPC wird nicht mehr weiterentwickelt.</dd>
<dt><a href="Virtual_Pascal" title="Virtual Pascal">Virtual Pascal</a></dt>
<dd>Diese inzwischen freie Implementierung eines Borland-kompatiblen Pascal-Compilers für <a href="OS/2" title="OS/2">OS/2</a> wurde auch auf andere Plattformen portiert, wird aber seit 2005 nicht mehr weiterentwickelt.</dd></dl>
<div class="mw-heading mw-heading3"><h3 id="Integrierte_Entwicklungsumgebungen">Integrierte Entwicklungsumgebungen</h3></div>
<dl><dt><a href="Lazarus_(Entwicklungsumgebung)" title="Lazarus (Entwicklungsumgebung)">Lazarus</a></dt>
<dd>Eine Entwicklungsumgebung für Free Pascal, die auch verschiedene Komponenten zur Verfügung stellt. Die IDE ist sehr Delphi-ähnlich gestaltet und verwendet unter Unix das <a href="GIMP-Toolkit" class="mw-redirect" title="GIMP-Toolkit">GTK+</a> als Grafik-Toolkit, unter Windows (win32/win64/wince) setzt es auf der nativen <a href="Programmierschnittstelle" title="Programmierschnittstelle">API</a> auf, und auf Apple-Betriebssystemen kann wahlweise die native <a href="Carbon_(Apple)" title="Carbon (Apple)">Carbon</a>-API oder das <a href="X-Window" class="mw-redirect" title="X-Window">X-Window</a>-System verwendet werden. Darüber hinaus unterstützt Lazarus <a href="Cross-Compiler" title="Cross-Compiler">Cross Compiling</a>, so dass auch Software für weitere Plattformen wie <a href="Windows_CE" class="mw-redirect" title="Windows CE">Windows CE</a>, OS/2, <a href="Palm_OS" title="Palm OS">Palm OS</a> oder <a href="Nintendo_DS" title="Nintendo DS">Nintendo DS</a> entwickelt werden kann.</dd>
<dt>Dev-Pascal</dt>
<dd>Eine unter Windows laufende IDE, die auf Free Pascal oder GNU-Pascal als Compiler aufsetzen kann. Sie wird nicht mehr weiterentwickelt.</dd>
<dt><a href="Embarcadero_Delphi" title="Embarcadero Delphi">Delphi</a></dt>
<dd>Nachfolger von Borland Pascal, für Windows.</dd>
<dt>Kyan Pascal</dt>
<dd>Eine 1986 von Kyan Software veröffentlichte, auf dem Heimcomputer <a href="Apple_II" title="Apple II">Apple II</a> lauffähige Pascal-Entwicklungsumgebung inklusive Editor, Assembler, Makroassembler und Programmierkurs.</dd>
<dt>Kyan Pascal 128</dt>
<dd>Eine 1987 von Kyan Software weiterentwickelte Version für die Heimcomputer <a href="Commodore_128" title="Commodore 128">Commodore 128</a> und <a href="Atari_800" title="Atari 800">Atari 800</a>.</dd>
<dt>Pascal C128</dt>
<dd>Eine vom <a href="Markt%2BTechnik_Verlag" title="Markt+Technik Verlag">Markt+Technik Verlag</a> veröffentlichte, auf dem Commodore 128 im C128-Modus lauffähige Pascal-Entwicklungsumgebung mit Compiler, Editor und Linker.</dd>
<dt>Profi-Pascal Plus</dt>
<dd>Eine 1987 von <a href="Data_Becker" title="Data Becker">Data Becker</a> veröffentlichte, auf dem Commodore 128 im C128-Modus lauffähige Pascal-Entwicklungsumgebung mit Compiler, Editor und Linker.</dd>
<dt><a href="QuickPascal" title="QuickPascal">QuickPascal</a></dt>
<dd>Eine 1989 von <a href="Microsoft" title="Microsoft">Microsoft</a> veröffentlichte Pascal-Entwicklungsumgebung für <a href="MS-DOS" title="MS-DOS">MS-DOS</a>.</dd>
<dt>Super Pascal 128</dt>
<dd>Eine 1986 von Abacus Software veröffentlichte, auf dem Commodore 128 im C128-Modus lauffähige Pascal-Entwicklungsumgebung inklusive Editor, Assembler und Dienstprogrammpaket.</dd>
<dt><a href="Turbo_Pascal" title="Turbo Pascal">Turbo Pascal</a></dt>
<dd>(Später <b>Borland Pascal</b>) Kommerziell erfolgreichste Pascal-IDE für MS-DOS.</dd>
<dt>HP 64800 Pascal compiler package</dt>
<dd>Beispielsweise bei der Entwicklung von <a href="Donkey_Kong" title="Donkey Kong">Donkey Kong</a> für <a href="ColecoVision" title="ColecoVision">ColecoVision</a>.</dd></dl>
<div class="mw-heading mw-heading2"><h2 id="Geschichte">Geschichte</h2></div>
<p>Pascal wurde nach dem französischen Mathematiker <a href="Blaise_Pascal" title="Blaise Pascal">Blaise Pascal</a> benannt. Die Entwicklung der Programmiersprache Algol (bis 1958) wie auch die ihrer Nachfolger war Produkt von Entwicklungskomitees. Niklaus Wirth war maßgeblich an der Erstellung des Abkömmlings Algol W beteiligt, das in Zürich entwickelt und 1966 fertiggestellt wurde.<sup id="cite_ref-9" class="reference"><a href="#cite_note-9"><span class="cite-bracket">[</span>9<span class="cite-bracket">]</span></a></sup> Er berichtete später von den Nachteilen einer gemeinsamen Entwicklung. Konsens innerhalb des Komitees musste mühsam erarbeitet werden, auch erschienen dem praktisch denkenden Wirth, der sich nicht nur als Wissenschaftler, sondern auch als Ingenieur sah, einige Entwicklungsziele mancher Kollegen als übertrieben und unumsetzbar.<sup id="cite_ref-Niklaus_Wirth_2002_10-0" class="reference"><a href="#cite_note-Niklaus_Wirth_2002-10"><span class="cite-bracket">[</span>10<span class="cite-bracket">]</span></a></sup>
</p><p>Im Jahr 1968 erhielt Wirth eine Professur an der ETH Zürich, wo er neben seiner Lehrtätigkeit Zeit fand, mit der Entwicklung einer neuen Sprache zu beginnen. Er arbeitete diesmal alleine und konnte Pascal im Laufe des Jahres 1969 fertigstellen. Einer der Gründe für die Neuentwicklung war laut Wirth das Fehlen einer für den universitären Unterricht geeigneten Sprache. Weder das zu unwissenschaftlich angelegte <a href="Fortran" title="Fortran">Fortran</a> noch das für die praktische Ingenieurstätigkeit ungeeignete Algol konnten Wirths Ansprüchen genügen. Über den Programmierunterricht hinaus sollte Pascal aber ebenso in der Wirtschaft, der Forschung und bei der Entwicklung von Compilern und Betriebssystemen einsetzbar sein.<sup id="cite_ref-Niklaus_Wirth_2002_10-1" class="reference"><a href="#cite_note-Niklaus_Wirth_2002-10"><span class="cite-bracket">[</span>10<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-11" class="reference"><a href="#cite_note-11"><span class="cite-bracket">[</span>11<span class="cite-bracket">]</span></a></sup>
</p><p>Weitere Ziele für die Entwicklung von Pascal bestanden daher darin, ein zuverlässiges und effizientes Werkzeug für das Schreiben großer Programme bereitzustellen<sup id="cite_ref-12" class="reference"><a href="#cite_note-12"><span class="cite-bracket">[</span>12<span class="cite-bracket">]</span></a></sup> und den "Canyon" zwischen wissenschaftlicher und kommerzieller Entwicklung, wie sie durch die damals verbreiteten Sprachen Fortran und COBOL verkörpert wurden, mit einer universellen Programmiersprache zu überbrücken<sup id="cite_ref-13" class="reference"><a href="#cite_note-13"><span class="cite-bracket">[</span>13<span class="cite-bracket">]</span></a></sup>.
</p>

<p>Nachdem Wirth die Sprache 1969 fertiggestellt hatte, folgte ein Jahr später die Entwicklung des ersten Pascal-Compilers. Dieser wurde für Computer der CDC 6000 Serie geschrieben und ging bereits 1970 in Betrieb. Im Jahr 1971 veröffentlichte Wirth die nur 28 Seiten lange Beschreibung<sup id="cite_ref-14" class="reference"><a href="#cite_note-14"><span class="cite-bracket">[</span>14<span class="cite-bracket">]</span></a></sup> der Sprache, 1972 konnten Lehrende Pascal erstmals für einführende Programmierkurse verwenden.<sup id="cite_ref-Niklaus_Wirth_2002_10-2" class="reference"><a href="#cite_note-Niklaus_Wirth_2002-10"><span class="cite-bracket">[</span>10<span class="cite-bracket">]</span></a></sup> 1973 folgte eine überarbeitete und 54 Seiten lange Überarbeitung der Spezifikation.<sup id="cite_ref-RR_5-1" class="reference"><a href="#cite_note-RR-5"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup>
</p>
<div class="Vorlage_Zitat" style="margin:1em 40px;">
<div style="margin:1em 0;"><blockquote style="margin:0;">
<p>„Oft wurde ich gefragt, wie man eine Programmiersprache ‚erfindet‘. Man kann das nicht wirklich beantworten, aber es ist sicherlich eine Frage der Erfahrung auf dem Gebiet der Programmierung und von sorgfältiger Überlegung. Manchmal sage ich: ‚So, wie man ein Flugzeug entwickelt. Man muss eine gewisse Anzahl nötiger Bauelemente identifizieren und diese dann zu einem funktionierenden Ganzen zusammenbauen.‘ Diese Antwort ist vielleicht nicht voll zufriedenstellend, aber zumindest passiert dem Resultat in beiden Fällen dasselbe, entweder es fliegt oder es stürzt ab.“
</p>
</blockquote>
</div><div class="cite" style="margin:-1em 0 1em 1em;">– <style data-mw-deduplicate="TemplateStyles:r261921330">
/* start https://de.wikipedia.org/ */


.mw-parser-output .Person{font-variant:small-caps}


/* end https://de.wikipedia.org/ */
</style><span class="Person h-card">Niklaus Wirth<sup id="cite_ref-15" class="reference"><a href="#cite_note-15"><span class="cite-bracket">[</span>15<span class="cite-bracket">]</span></a></sup></span></div></div>
<div class="mw-heading mw-heading2"><h2 id="Kritik">Kritik</h2></div>
<p>Da die Sprache als Lehrsprache konzipiert war, wies das Standard-Pascal einige Merkmale auf, die den kommerziellen Einsatz erschwerten: Das Konzept für Dateizugriffe („file I/O“) war nicht mächtig, die <a href="Laufzeitbibliothek" title="Laufzeitbibliothek">Laufzeitbibliothek</a> wenig umfangreich, und Zeichenketten konnten nur über Umwege (<code>packed array</code>) direkt im Code verwendet werden. Das führte dazu, dass praktisch jede kommerzielle Implementierung hierzu eigene Lösungen anbot, was zunächst (ähnlich wie die Diversifizierung bei C) zu eigenen Pascal-Dialekten und damit zu Kompatibilitätsproblemen führte. Mit der monopolartigen Dominanz der Turbo-Pascal-Produkte von <a href="Borland" title="Borland">Borland</a> verschwanden diese Unterschiede fast vollständig.
</p><p>Ein anderer wesentlicher Nachteil war, dass eine Modularisierung im Sinne getrennter Kompilierung nicht vorgesehen war – was mit der Weiterentwicklung <a href="Modula-2" title="Modula-2">Modula-2</a> geändert wurde. Plattformspezifische Implementierungen sahen dafür eigene Lösungen vor (z.&nbsp;B. die Units von Turbo-Pascal, fortgeführt in äquivalenten Unit-Implementierungen in Free Pascal und Delphi, oder später die Module in ANSI/ISO Extended Pascal).
</p>
<div class="mw-heading mw-heading2"><h2 id="Aufstieg_in_den_1970er_und_1980er_Jahren">Aufstieg in den 1970er und 1980er Jahren</h2></div>
<p>In den zwei Jahrzehnten nach 1975 gewann Pascal mehr Einfluss und wurde zu einer dominierenden Programmiersprache auf wichtigen Plattformen wie Apple II, Apple III, Apple Lisa, Commodore-Systemen, Z-80-basierten Maschinen und IBM PC. Dies ist unter anderem der Entwicklung von UCSD-Pascal und Turbo Pascal zu verdanken<sup id="cite_ref-16" class="reference"><a href="#cite_note-16"><span class="cite-bracket">[</span>16<span class="cite-bracket">]</span></a></sup>.
</p><p>Trotz der ursprünglichen Kritik entwickelte sich Pascal weiter, so dass die Mehrzahl der früheren Probleme in kommerziellen Implementierungen behoben wurden. Allerdings waren die Lösungen meist zwischen den Compilern inkompatibel. In den 1990er Jahren vereinfachte sich die Situation allerdings dadurch, dass sich die Varianten graduell zwei Hauptkategorien, ISO-Pascal und Borland-ähnlichem Pascal, annäherten.
</p><p>Einige der verbleibenden Schwierigkeiten, die durch die Unterschiede in den Pascal-Implementierungen entstanden, wurden später teilweise in Free Pascal gelöst, das verschiedene Dialekte mit Modus-Direktiven unterstützt<sup id="cite_ref-17" class="reference"><a href="#cite_note-17"><span class="cite-bracket">[</span>17<span class="cite-bracket">]</span></a></sup>.
</p>
<div class="mw-heading mw-heading2"><h2 id="Weiterentwicklungen">Weiterentwicklungen</h2></div>
<ul><li><a rel="nofollow" class="external text" href="http://www.xsc.de/">Pascal-XSC</a> Pascal Dialekt mit „Language eXtensions for Scientific Computation“</li>
<li><a href="Oberon_(Programmiersprache)" title="Oberon (Programmiersprache)">Oberon</a>, Oberon-2</li>
<li><a href="POW!" title="POW!">POW!</a> – basiert auf Oberon und Pascal</li>
<li><a href="Component_Pascal" title="Component Pascal">Component Pascal</a> – Weiterentwicklung von Oberon-2</li>
<li><a href="Embarcadero_Delphi" title="Embarcadero Delphi">Embarcadero Delphi</a> – Objektorientiertes Pascal als Weiterentwicklung von <a href="Borland_Pascal" title="Borland Pascal">Borland Pascal</a>.</li>
<li><a href="Free_Pascal" title="Free Pascal">Free Pascal</a> – eine zu Delphi weitgehend kompatible freie Implementierung. Dazu gibt es die Delphi ähnliche IDE <a href="Lazarus_(Entwicklungsumgebung)" title="Lazarus (Entwicklungsumgebung)">Lazarus</a>.</li>
<li>RemObjects Chrome, Oxygene, nun lizenziert als <a href="Embarcadero_Delphi" title="Embarcadero Delphi">Delphi</a> Prism von <a href="CodeGear" title="CodeGear">CodeGear</a></li>
<li><a href="PocketStudio" title="PocketStudio">PocketStudio</a></li>
<li><a href="Pascal_Script" title="Pascal Script">Pascal Script</a></li>
<li><a href="StatPascal" title="StatPascal">StatPascal</a></li>
<li><a href="Modula-2" title="Modula-2">Modula-2</a></li>
<li>Concurrent Pascal – Pascal für nebenläufige Programme</li>
<li>HP PPL, eine von <a href="Hewlett-Packard" class="mw-redirect" title="Hewlett-Packard">HP</a> entwickelte Pascal-Variante für <a href="Computeralgebra" title="Computeralgebra">Computeralgebra</a></li></ul>
<div class="mw-heading mw-heading2"><h2 id="Literatur">Literatur</h2></div>
<ul><li>Niklaus Wirth: <i>The Programming Language Pascal.</i> In: <i>Acta Informatica.</i> Volume 1, 1971, S. 35–63. <a rel="nofollow" class="external text" href="https://oberoncore.ru/_media/library/wirth_the_programming_language_pascal.pdf">(online)</a></li>
<li>Niklaus Wirth: <i>The Programming Language Pascal. Revised Report.</i> Eidgenössische Technische Hochschule, Zürich 1973. <a rel="nofollow" class="external text" href="http://e-collection.library.ethz.ch/eserv/eth:3059/eth-3059-01.pdf">(online)</a></li>
<li>Niklaus Wirth: <i>Algorithmen und Datenstrukturen.</i> Stuttgart 1975, ISBN 3-519-02330-X.</li>
<li>Niklaus Wirth: <i>Pascal and its Successors.</i> In: Manfred Broy, Ernst Denert (Hrsg.): <i>Software Pioneers: Contributions to Software Engineering.</i> Springer-Verlag, Berlin/Heidelberg 2002, ISBN 3-540-43081-4, S. 108–119. <a rel="nofollow" class="external text" href="https://www.swissdelphicenter.ch/en/niklauswirth.php">(online)</a></li>
<li>Kathleen Jensen, Niklaus Wirth: <i>Pascal. User Manual and Report.</i> (= <i>Lecture notes in computer science.</i> 18). Springer, Berlin 1974.</li>
<li>Kathleen Jensen, Niklaus Wirth: <i>Pascal User Manual and Report. ISO Pascal Standard.</i> 4. Auflage. Springer-Verlag, 1991, ISBN 3-540-97649-3.</li>
<li>Steven Pemberton, Martin Daniels, Ellis Horwood: <i>Pascal Implementation: The P4 Compiler and Interpreter.</i> ISBN 0-13-653031-1. (<a rel="nofollow" class="external text" href="https://homepages.cwi.nl/~steven/pascal/">online</a>)</li></ul>
<div class="mw-heading mw-heading2"><h2 id="Weblinks">Weblinks</h2></div>
<div class="sisterproject" style="margin:0.1em 0 0 0;"><div class="noresize noviewer" style="display:inline-block; line-height:10px; min-width:1.6em; text-align:center;" aria-hidden="true" role="presentation"><span class="mw-default-size" typeof="mw:File"><span title="Commons"></span></span></div><b><span class=""><a class="external text" href="https://commons.wikimedia.org/wiki/Category:Pascal_(programming_language)?uselang=de"><span lang="en">Commons</span>: Pascal (Programmiersprache)</a></span></b>&nbsp;– Sammlung von Bildern, Videos und Audiodateien</div>
<div class="sisterproject" style="margin:0.1em 0 0 0;"><div class="noviewer" style="display:inline-block; line-height:10px; min-width:1.6em; text-align:center;" aria-hidden="true" role="presentation"><span class="mw-default-size" typeof="mw:File"><span title="Wikibooks"></span></span></div><b><a href="https://de.wikibooks.org/wiki/GNU-Pascal_in_Beispielen" class="extiw external" title="b:GNU-Pascal in Beispielen">Wikibooks: GNU-Pascal in Beispielen</a></b>&nbsp;– Lern- und Lehrmaterialien</div>
<ul><li><a rel="nofollow" class="external text" href="http://www.bitsavers.org/bits/UCSD_Pascal/">UCSD-Pascal Source-Code</a> (englisch)</li>
<li><a href="Brian_W._Kernighan" title="Brian W. Kernighan">Brian W. Kernighan</a>: <a rel="nofollow" class="external text" href="https://www.lysator.liu.se/c/bwk-on-pascal.html"><i>Why Pascal is Not My Favorite Programming Language.</i></a> AT&amp;T Bell Laboratories, Murray Hill, New Jersey 1981. Ein Artikel, der ausführlich anhand von Beispielen auf die Nachteile von Pascal eingeht und Pascal mit anderen Programmiersprachen wie C oder Fortran vergleicht.</li></ul>
<div class="mw-heading mw-heading2"><h2 id="Einzelnachweise">Einzelnachweise</h2></div>
<ol class="references">
<li id="cite_note-1"><span class="mw-cite-backlink"><a href="#cite_ref-1">↑</a></span> <span class="reference-text">Niklaus Wirth: <i>The Programming Language Pascal.</i> In: <i>Acta Informatica.</i> Band 1, 1971, S. 35–63, <a href="https://doi.org/10.1007/BF00264291" class="extiw external" title="doi:10.1007/BF00264291">doi:10.1007/BF00264291</a>.</span>
</li>
<li id="cite_note-2"><span class="mw-cite-backlink"><a href="#cite_ref-2">↑</a></span> <span class="reference-text"><span class="cite">M. Jordan: <a rel="nofollow" class="external text" href="https://www.land-der-erfinder.ch/?tag=niklaus-wirth"><i>„Tag der Erfinder“ Heute: Niklaus Wirth.</i></a> In: <i>land-der-erfinder.ch.</i> 15.&nbsp;Februar 2011,<span class="Abrufdatum"> abgerufen am 21.&nbsp;Mai 2012</span>.</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&amp;rfr_id=info%3Asid%2Fde.wikipedia.org%3APascal+%28Programmiersprache%29&amp;rft.title=%E2%80%9ETag+der+Erfinder%E2%80%9C+Heute%3A+Niklaus+Wirth&amp;rft.description=%E2%80%9ETag+der+Erfinder%E2%80%9C+Heute%3A+Niklaus+Wirth&amp;rft.identifier=https%3A%2F%2Fwww.land-der-erfinder.ch%2F%3Ftag%3Dniklaus-wirth&amp;rft.creator=M.+Jordan&amp;rft.date=2011-02-15">&nbsp;</span></span>
</li>
<li id="cite_note-3"><span class="mw-cite-backlink"><a href="#cite_ref-3">↑</a></span> <span class="reference-text"><span class="cite">Andreas Schwill: <a rel="nofollow" class="external text" href="http://www.hyfisch.de/didaktik/Forschung/INFOS95.pdf"><i>Programmierstile im Anfangsunterricht.</i></a> (PDF; 38&nbsp;kB) In: <i>hyfisch.de.</i> <a href="Universit%C3%A4t_Paderborn" title="Universität Paderborn">Universität Paderborn</a>, Fachbereich Mathematik/Informatik,<span class="Abrufdatum"> abgerufen am 21.&nbsp;Mai 2012</span>.</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&amp;rfr_id=info%3Asid%2Fde.wikipedia.org%3APascal+%28Programmiersprache%29&amp;rft.title=Programmierstile+im+Anfangsunterricht&amp;rft.description=Programmierstile+im+Anfangsunterricht&amp;rft.identifier=http%3A%2F%2Fwww.hyfisch.de%2Fdidaktik%2FForschung%2FINFOS95.pdf&amp;rft.creator=Andreas+Schwill&amp;rft.publisher=%5B%5BUniversit%C3%A4t+Paderborn%5D%5D%2C+Fachbereich+Mathematik%2FInformatik">&nbsp;</span></span>
</li>
<li id="cite_note-4"><span class="mw-cite-backlink"><a href="#cite_ref-4">↑</a></span> <span class="reference-text"><span class="cite"><a rel="nofollow" class="external text" href="http://www.delphi-treff.de/ueber-delphi/das-produkt/historie/"><i>Programmierstile im Anfangsunterricht.</i></a> In: <i>delphi-treff.de.</i><span class="Abrufdatum"> Abgerufen am 21.&nbsp;Mai 2012</span>.</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&amp;rfr_id=info%3Asid%2Fde.wikipedia.org%3APascal+%28Programmiersprache%29&amp;rft.title=Programmierstile+im+Anfangsunterricht&amp;rft.description=Programmierstile+im+Anfangsunterricht&amp;rft.identifier=http%3A%2F%2Fwww.delphi-treff.de%2Fueber-delphi%2Fdas-produkt%2Fhistorie%2F">&nbsp;</span></span>
</li>
<li id="cite_note-RR-5"><span class="mw-cite-backlink">↑ <sup><a href="#cite_ref-RR_5-0">a</a></sup> <sup><a href="#cite_ref-RR_5-1">b</a></sup></span> <span class="reference-text">Niklaus Wirth: <i>The Programming Language Pascal. Revised Report.</i> 1973.</span>
</li>
<li id="cite_note-6"><span class="mw-cite-backlink"><a href="#cite_ref-6">↑</a></span> <span class="reference-text"><span class="cite"><a rel="nofollow" class="external text" href="https://www.freepascal.org/docs-html/ref/refse109.html"><i>Inc/Dec operators.</i></a> In: <i>freepascal.org.</i><span class="Abrufdatum"> Abgerufen am 28.&nbsp;August 2024</span> (englisch).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&amp;rfr_id=info%3Asid%2Fde.wikipedia.org%3APascal+%28Programmiersprache%29&amp;rft.title=Inc%2FDec+operators&amp;rft.description=Inc%2FDec+operators&amp;rft.identifier=https%3A%2F%2Fwww.freepascal.org%2Fdocs-html%2Fref%2Frefse109.html&amp;rft.language=en">&nbsp;</span></span>
</li>
<li id="cite_note-7"><span class="mw-cite-backlink"><a href="#cite_ref-7">↑</a></span> <span class="reference-text">Kathleen Jensen, Niklaus Wirth: <i>Pascal. User Manual and Report.</i> Springer, Berlin 1974.</span>
</li>
<li id="cite_note-8"><span class="mw-cite-backlink"><a href="#cite_ref-8">↑</a></span> <span class="reference-text">Kathleen Jensen, Niklaus Wirth: <i>Pascal. User Manual and Report.</i> Springer, Berlin 1974, Vorwort</span>
</li>
<li id="cite_note-9"><span class="mw-cite-backlink"><a href="#cite_ref-9">↑</a></span> <span class="reference-text">N. Wirth, C. A. R. Hoare: <i>A Contribution to the development of ALGOL.</i> In: <i>Comm. ACM.</i> 9, 6, Juni 1966, S. 413–432.</span>
</li>
<li id="cite_note-Niklaus_Wirth_2002-10"><span class="mw-cite-backlink">↑ <sup><a href="#cite_ref-Niklaus_Wirth_2002_10-0">a</a></sup> <sup><a href="#cite_ref-Niklaus_Wirth_2002_10-1">b</a></sup> <sup><a href="#cite_ref-Niklaus_Wirth_2002_10-2">c</a></sup></span> <span class="reference-text">Niklaus Wirth: <i>Pascal and its Successors.</i> 2002, S. 108–119.</span>
</li>
<li id="cite_note-11"><span class="mw-cite-backlink"><a href="#cite_ref-11">↑</a></span> <span class="reference-text">Niklaus Wirth: <cite class="lang" lang="en" dir="auto" style="font-style:italic">Modular Programming Languages</cite>. In: <cite class="lang" lang="en" dir="auto" style="font-style:italic">Lecture Notes in Computer Science</cite>. <span style="white-space:nowrap">Band<span style="display:inline-block;width:.2em">&nbsp;</span>1897</span>, 2000, ISBN 978-3-540-67958-5, <a rel="nofollow" class="external text" href="https://link.springer.com/chapter/10.1007/10722581_1">The Development of Procedural Programming Languages Personal Contributions and Perspectives</a>, <span style="white-space:nowrap">S.<span style="display:inline-block;width:.2em">&nbsp;</span>1–10</span>, <a href="Digital_Object_Identifier" title="Digital Object Identifier">doi</a>:<span class="uri-handle" style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://doi.org/10.1007/10722581_1">10.1007/10722581_1</a></span> (englisch).<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rfr_id=info:sid/de.wikipedia.org:Pascal+%28Programmiersprache%29&amp;rft.atitle=Modular+Programming+Languages&amp;rft.au=Niklaus+Wirth&amp;rft.btitle=Lecture+Notes+in+Computer+Science&amp;rft.date=2000&amp;rft.doi=10.1007%2F10722581_1&amp;rft.genre=book&amp;rft.isbn=9783540679585&amp;rft.pages=1-10&amp;rft.volume=1897" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-12"><span class="mw-cite-backlink"><a href="#cite_ref-12">↑</a></span> <span class="reference-text">Niklaus Wirth: <cite class="lang" lang="en" dir="auto" style="font-style:italic">The Programming Language Pascal</cite>. In: <cite class="lang" lang="en" dir="auto" style="font-style:italic">Acta Informatica</cite>. <span style="white-space:nowrap">Band<span style="display:inline-block;width:.2em">&nbsp;</span>1</span>, <span style="white-space:nowrap">Nr.<span style="display:inline-block;width:.2em">&nbsp;</span>1</span>, 1971, <span style="white-space:nowrap">S.<span style="display:inline-block;width:.2em">&nbsp;</span>35–63</span>, <a href="Digital_Object_Identifier" title="Digital Object Identifier">doi</a>:<span class="uri-handle" style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://doi.org/10.1007/BF00264291">10.1007/BF00264291</a></span> (englisch).<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rfr_id=info:sid/de.wikipedia.org:Pascal+%28Programmiersprache%29&amp;rft.atitle=The+Programming+Language+Pascal&amp;rft.au=Niklaus+Wirth&amp;rft.date=1971&amp;rft.doi=10.1007%2FBF00264291&amp;rft.genre=journal&amp;rft.issue=1&amp;rft.jtitle=Acta+Informatica&amp;rft.pages=35-63&amp;rft.volume=1" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-13"><span class="mw-cite-backlink"><a href="#cite_ref-13">↑</a></span> <span class="reference-text">Niklaus Wirth: <cite class="lang" lang="en" dir="auto" style="font-style:italic">Recollections about the development of Pascal</cite>. In: <cite class="lang" lang="en" dir="auto" style="font-style:italic">History of programming languages---II</cite>. Januar 1996, <span style="white-space:nowrap">S.<span style="display:inline-block;width:.2em">&nbsp;</span>97–120</span>, <a href="Digital_Object_Identifier" title="Digital Object Identifier">doi</a>:<span class="uri-handle" style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://doi.org/10.1145/234286.1057812">10.1145/234286.1057812</a></span> (englisch).<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rfr_id=info:sid/de.wikipedia.org:Pascal+%28Programmiersprache%29&amp;rft.atitle=Recollections+about+the+development+of+Pascal&amp;rft.au=Niklaus+Wirth&amp;rft.btitle=History+of+programming+languages---II&amp;rft.date=1996-01&amp;rft.doi=10.1145%2F234286.1057812&amp;rft.genre=book&amp;rft.pages=97-120" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-14"><span class="mw-cite-backlink"><a href="#cite_ref-14">↑</a></span> <span class="reference-text">Niklaus Wirth: <i>The Programming Language Pascal.</i> 1971.</span>
</li>
<li id="cite_note-15"><span class="mw-cite-backlink"><a href="#cite_ref-15">↑</a></span> <span class="reference-text">Niklaus Wirth: <i>Pascal and its Successors.</i> 2002, S. 108–119: <i>Many times I have been asked how one "invents" a programming language. One cannot really tell, but it certainly is a matter of experience with the subject of programming, and of careful deliberation. Sometimes I answered: "Like one designs an airplane. One must identify a number of necessary building blocks and materials, and then assemble and combine them properly to a functioning whole". This answer may not be entirely satisfactory, but at least in both cases the result either flies or crashes.</i></span>
</li>
<li id="cite_note-16"><span class="mw-cite-backlink"><a href="#cite_ref-16">↑</a></span> <span class="reference-text"><span class="cite">Diego Crespo: <a rel="nofollow" class="external text" href="https://www.deusinmachina.net/p/pascal-the-language-that-almost-took"><i>Pascal: The language that almost took over the world part 1.</i></a> In: <i>www.deusinmachina.net.</i><span class="Abrufdatum"> Abgerufen am 4.&nbsp;Januar 2025</span> (englisch).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&amp;rfr_id=info%3Asid%2Fde.wikipedia.org%3APascal+%28Programmiersprache%29&amp;rft.title=Pascal%3A+The+language+that+almost+took+over+the+world+part+1&amp;rft.description=Pascal%3A+The+language+that+almost+took+over+the+world+part+1&amp;rft.identifier=&amp;rft.creator=Diego%26%2332%3BCrespo&amp;rft.date=&amp;rft.language=en">&nbsp;</span></span>
</li>
<li id="cite_note-17"><span class="mw-cite-backlink"><a href="#cite_ref-17">↑</a></span> <span class="reference-text"><span class="cite">Diego Crespo: <a rel="nofollow" class="external text" href="https://www.deusinmachina.net/p/pascal-the-language-that-almost-took-56a"><i>Pascal: The language that almost took over the world part 2.</i></a> In: <i>www.deusinmachina.net.</i><span class="Abrufdatum"> Abgerufen am 4.&nbsp;Januar 2025</span> (englisch).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&amp;rfr_id=info%3Asid%2Fde.wikipedia.org%3APascal+%28Programmiersprache%29&amp;rft.title=Pascal%3A+The+language+that+almost+took+over+the+world+part+2&amp;rft.description=Pascal%3A+The+language+that+almost+took+over+the+world+part+2&amp;rft.identifier=&amp;rft.creator=Diego%26%2332%3BCrespo&amp;rft.date=&amp;rft.language=en">&nbsp;</span></span>
</li>
</ol></div><!--htdig_noindex--><div><div class="zim-footer">
Dieser Artikel wurde von <a class="external text" title="Zuletzt bearbeitet am 2025-10-31" href="https://de.wikipedia.org/wiki/?title=Pascal_(Programmiersprache)&amp;oldid=261095210">Wikipedia</a> herausgegeben. Der Text ist unter <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.de">Creative Commons Attribution-Share Alike 4.0</a> verfügbar, sofern nicht anders angegeben. Für die Mediendateien können zusätzliche Bedingungen gelten.
</div>
</div><!--/htdig_noindex--></div>
</div>
</main>
</div>
</div>
</div>
<script src="./_webp_/webpHandler.js"></script>

</body></html>